Junior Engineer, Senior Engineer

Junior-to-senior advice#

For junior engineers who want some ideas for directions to improve, it can be an interesting exercise to do a series of contrasting statements. I went through a long list of junior-to-senior advice online and compiled these approximately thirty comparisons in four categories:

• Code
• Learning
• Behavior
• Team

📝 Note: Please note that these are pithy opinions, not requirements!

We are all junior in some way, senior in others. You’ll find that elements of these ideas permeate the principles, tactics, and strategies throughout this course.

Code#

• Juniors collect solutions. Seniors collect patterns.

• Juniors get code working. Seniors keep code working.

• Juniors deliver features. Seniors deliver outcomes.

• Juniors fix bugs after they create them. Seniors create tooling to preclude bugs.

• Juniors write tests because it’s required. Seniors require writing good tests because they’ve seen what happens when you don’t.

• Juniors hate technical debt. Seniors have written code that became technical debt (and know when to let it be and when to migrate).

• Juniors love to keep code DRY. Seniors Avoid Hasty Abstractions.

• Juniors try to write the best code the first time. Seniors understand code is read, moved, copied, and deleted far more than it is written.

• Juniors know how to use their tools. Seniors know when not to use them.

Learning#

• Juniors make one-off side projects. Seniors use their side projects daily, often to make themselves more productive at their day job.
• Juniors learn to find the right answers. Seniors learn to ask the right questions.
• Juniors know what they need to know. Seniors know what they don’t need to know.
• Juniors should absorb best practices from others. Seniors can derive best practices from first principles and personal pain.
• Juniors get stuck without docs and tutorials. Seniors aren’t afraid to read specs and view sources.
• Juniors might have strongly held beliefs. Seniors have had to change strongly held beliefs.
• Juniors question themselves when they fail. Seniors know they just need to give themselves more time and try again.
• Juniors stay on top of the news. Seniors keep track of trends.
• Juniors try to avoid mistakes. Seniors have made them all and know how to recover.
• Juniors laugh at software tropes. Seniors know there’s a grain of truth in all of them.

Behavior#

• Juniors seek the best. Seniors love the good enough.
• Juniors should say “Yes” often. Seniors should say “No” more.
• Juniors should try to do the jobs they are given. Seniors should redesign their jobs as needed.
• Juniors complain about open source. Seniors understand open source only works thanks to contributors, not complainers.
• Juniors solve problems. Seniors identify problems before they become problems.
• Juniors start from what others say. Seniors start with what they need.
• Juniors know how to build. Seniors know when to buy.
• Juniors compare developer experience. Seniors look for hidden costs in user experience and in abstraction leaks.
• Juniors write as an afterthought. Seniors weigh writing as much as coding.
• Juniors leave comments. Seniors provide context.

Team#

• Juniors work within their teams. Seniors know when and how to work across teams.
• Juniors grow their own output. Seniors grow their team’s output.
• Juniors pair to learn best practices. Seniors pair to share expertise and see things in a new light.
• Juniors get roped in. Seniors get to buy-in.
• Juniors must earn trust. Seniors inspire trust.
• Juniors seek out mentors. Seniors know how to learn from their peers.
• Juniors work on improving themselves. Seniors work on improving their team and being force multipliers through teaching, mentorship, and leadership.

📝 Note: Note that these are pithy, idealized comparisons just to get your imagination going on ways to improve yourself. In no way am I stating that any quality is unique to juniors or seniors or that all seniors or all juniors practice all these qualities all the time.